package com.icen.utils.comm;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * List Utils Class
 * 
 * @author IcenHan
 * 
 */
public class ListUtils {
	/**
	 * 获取List集合的大小
	 * 
	 * @param list
	 *            集合
	 * @return int
	 */
	public static <V> int getSize(List<V> list) {
		return list == null ? 0 : list.size();
	}

	/**
	 * 将List集合转换为字符串,默认使用逗号作为分隔符
	 * 
	 * @param list
	 *            需要转换的集合
	 * @return String
	 */
	public static <V> String listToStr(List<V> list) {
		return listToStr(list, null);
	}

	/**
	 * 将List集合转换为字符串
	 * 
	 * @param list
	 *            需要转换的集合
	 * @param separator
	 *            分隔符
	 * @return String
	 */
	public static String listToStr(List<String> list, char separator) {
		return listToStr(list, new String(new char[] { separator }));
	}

	/**
	 * 将List集合转换为字符串
	 * 
	 * @param list
	 *            需要转换的集合
	 * @param separator
	 *            分隔符
	 * @return String
	 */
	public static <V> String listToStr(List<V> list, String separator) {
		if (ValidateUtils.isEmpty(list)) {
			return "";
		}
		if (separator == null) {
			separator = ",";
		}

		StringBuilder joinStr = new StringBuilder();
		for (int i = 0; i < list.size(); i++) {
			joinStr.append(list.get(i));
			if (i != list.size() - 1) {
				joinStr.append(separator);
			}
		}
		return joinStr.toString();
	}

	/**
	 * 倒置List集合
	 * 
	 * @param list
	 *            集合
	 * @return List
	 */
	public static <V> List<V> invertList(List<V> list) {
		if (ValidateUtils.isEmpty(list)) {
			return list;
		}
		List<V> invertList = new ArrayList<V>(list.size());
		for (int i = list.size() - 1; i >= 0; i--) {
			invertList.add(list.get(i));
		}
		return invertList;
	}

	/**
	 * 向List集合添加数据
	 * 
	 * @param list
	 *            原集合
	 * @param entry
	 *            添加的数据
	 * @return boolean
	 */
	public static <V> boolean addEntry(List<V> list, V entry) {
		return (list != null && !list.contains(entry)) ? list.add(entry)
				: false;
	}

	/**
	 * 添加不是null的值
	 * 
	 * @param list
	 * @param value
	 * @return boolean
	 */
	public static <V> boolean addNotNullValue(List<V> list, V value) {
		return (list != null && value != null) ? list.add(value) : false;
	}

	/**
	 * 将两个List集合中不同的数据加入到ListA集合,并返回添加的数目
	 * 
	 * @param listA
	 * @param listB
	 * @return int
	 */
	public static <V> int addList(List<V> listA, List<V> listB) {
		if (listA == null || ValidateUtils.isEmpty(listB)) {
			return 0;
		}
		int sourceCount = listA.size();
		for (V entry : listB) {
			if (!listA.contains(entry)) {
				listA.add(entry);
			}
		}
		return listA.size() - sourceCount;
	}

	/**
	 * 去除List集合中的重复数据,并返回重复数据的个数
	 * 
	 * @param list
	 * @return int
	 */
	public static <V> int removerRepeat(List<V> list) {
		if (ValidateUtils.isEmpty(list)) {
			return 0;
		}

		int sourceCount = list.size();
		int sourceListSize = list.size();
		for (int i = 0; i < sourceListSize; i++) {
			for (int j = (i + 1); j < sourceListSize; j++) {
				if (list.get(i).equals(list.get(j))) {
					list.remove(j);
					sourceListSize = list.size();
					j--;
				}
			}
		}
		return sourceCount - list.size();
	}
}
